<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>Idioms and Anti-Idioms in Python &mdash; Python v2.6.2 documentation</title>
    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '../',
        VERSION:     '2.6.2',
        COLLAPSE_MODINDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="../_static/jquery.js"></script>
    <script type="text/javascript" src="../_static/doctools.js"></script>
    <link rel="search" type="application/opensearchdescription+xml"
          title="Search within Python v2.6.2 documentation"
          href="../_static/opensearch.xml"/>
    <link rel="author" title="About these documents" href="../about.html" />
    <link rel="copyright" title="Copyright" href="../copyright.html" />
    <link rel="top" title="Python v2.6.2 documentation" href="../index.html" />
    <link rel="up" title="Python HOWTOs" href="index.html" />
    <link rel="next" title="Functional Programming HOWTO" href="functional.html" />
    <link rel="prev" title="Curses Programming with Python" href="curses.html" />
    <link rel="shortcut icon" type="image/png" href="../_static/py.png" />
 

  </head>
  <body>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="../modindex.html" title="Global Module Index"
             accesskey="M">modules</a> |</li>
        <li class="right" >
          <a href="functional.html" title="Functional Programming HOWTO"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="curses.html" title="Curses Programming with Python"
             accesskey="P">previous</a> |</li>
        <li><img src="../_static/py.png" alt=""
                 style="vertical-align: middle; margin-top: -1px"/></li>
        <li><a href="../index.html">Python v2.6.2 documentation</a> &raquo;</li>

          <li><a href="index.html" accesskey="U">Python HOWTOs</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="idioms-and-anti-idioms-in-python">
<h1>Idioms and Anti-Idioms in Python<a class="headerlink" href="#idioms-and-anti-idioms-in-python" title="Permalink to this headline">¶</a></h1>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Author:</th><td class="field-body">Moshe Zadka</td>
</tr>
</tbody>
</table>
<p>This document is placed in the public domain.</p>
<div class="topic">
<p class="topic-title first">Abstract</p>
<p>This document can be considered a companion to the tutorial. It shows how to use
Python, and even more importantly, how <em>not</em> to use Python.</p>
</div>
<div class="section" id="language-constructs-you-should-not-use">
<h2>Language Constructs You Should Not Use<a class="headerlink" href="#language-constructs-you-should-not-use" title="Permalink to this headline">¶</a></h2>
<p>While Python has relatively few gotchas compared to other languages, it still
has some constructs which are only useful in corner cases, or are plain
dangerous.</p>
<div class="section" id="from-module-import">
<h3>from module import *<a class="headerlink" href="#from-module-import" title="Permalink to this headline">¶</a></h3>
<div class="section" id="inside-function-definitions">
<h4>Inside Function Definitions<a class="headerlink" href="#inside-function-definitions" title="Permalink to this headline">¶</a></h4>
<p><tt class="docutils literal"><span class="pre">from</span> <span class="pre">module</span> <span class="pre">import</span> <span class="pre">*</span></tt> is <em>invalid</em> inside function definitions. While many
versions of Python do not check for the invalidity, it does not make it more
valid, no more then having a smart lawyer makes a man innocent. Do not use it
like that ever. Even in versions where it was accepted, it made the function
execution slower, because the compiler could not be certain which names are
local and which are global. In Python 2.1 this construct causes warnings, and
sometimes even errors.</p>
</div>
<div class="section" id="at-module-level">
<h4>At Module Level<a class="headerlink" href="#at-module-level" title="Permalink to this headline">¶</a></h4>
<p>While it is valid to use <tt class="docutils literal"><span class="pre">from</span> <span class="pre">module</span> <span class="pre">import</span> <span class="pre">*</span></tt> at module level it is usually
a bad idea. For one, this loses an important property Python otherwise has &#8212;
you can know where each toplevel name is defined by a simple &#8220;search&#8221; function
in your favourite editor. You also open yourself to trouble in the future, if
some module grows additional functions or classes.</p>
<p>One of the most awful question asked on the newsgroup is why this code:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">f</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="s">&quot;www&quot;</span><span class="p">)</span>
<span class="n">f</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
</pre></div>
</div>
<p>does not work. Of course, it works just fine (assuming you have a file called
&#8220;www&#8221;.) But it does not work if somewhere in the module, the statement <tt class="docutils literal"><span class="pre">from</span> <span class="pre">os</span>
<span class="pre">import</span> <span class="pre">*</span></tt> is present. The <a title="Miscellaneous operating system interfaces." class="reference external" href="../library/os.html#module-os"><tt class="xref docutils literal"><span class="pre">os</span></tt></a> module has a function called <a title="open" class="reference external" href="../library/functions.html#open"><tt class="xref docutils literal"><span class="pre">open()</span></tt></a>
which returns an integer. While it is very useful, shadowing builtins is one of
its least useful properties.</p>
<p>Remember, you can never know for sure what names a module exports, so either
take what you need &#8212; <tt class="docutils literal"><span class="pre">from</span> <span class="pre">module</span> <span class="pre">import</span> <span class="pre">name1,</span> <span class="pre">name2</span></tt>, or keep them in the
module and access on a per-need basis &#8212;  <tt class="docutils literal"><span class="pre">import</span> <span class="pre">module;print</span> <span class="pre">module.name</span></tt>.</p>
</div>
<div class="section" id="when-it-is-just-fine">
<h4>When It Is Just Fine<a class="headerlink" href="#when-it-is-just-fine" title="Permalink to this headline">¶</a></h4>
<p>There are situations in which <tt class="docutils literal"><span class="pre">from</span> <span class="pre">module</span> <span class="pre">import</span> <span class="pre">*</span></tt> is just fine:</p>
<ul class="simple">
<li>The interactive prompt. For example, <tt class="docutils literal"><span class="pre">from</span> <span class="pre">math</span> <span class="pre">import</span> <span class="pre">*</span></tt> makes Python an
amazing scientific calculator.</li>
<li>When extending a module in C with a module in Python.</li>
<li>When the module advertises itself as <tt class="docutils literal"><span class="pre">from</span> <span class="pre">import</span> <span class="pre">*</span></tt> safe.</li>
</ul>
</div>
</div>
<div class="section" id="unadorned-exec-execfile-and-friends">
<h3>Unadorned <a class="reference external" href="../reference/simple_stmts.html#exec"><tt class="xref docutils literal"><span class="pre">exec</span></tt></a>, <a title="execfile" class="reference external" href="../library/functions.html#execfile"><tt class="xref docutils literal"><span class="pre">execfile()</span></tt></a> and friends<a class="headerlink" href="#unadorned-exec-execfile-and-friends" title="Permalink to this headline">¶</a></h3>
<p>The word &#8220;unadorned&#8221; refers to the use without an explicit dictionary, in which
case those constructs evaluate code in the <em>current</em> environment. This is
dangerous for the same reasons <tt class="docutils literal"><span class="pre">from</span> <span class="pre">import</span> <span class="pre">*</span></tt> is dangerous &#8212; it might step
over variables you are counting on and mess up things for the rest of your code.
Simply do not do that.</p>
<p>Bad examples:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mf">1</span><span class="p">:]:</span>
<span class="gp">&gt;&gt;&gt; </span>    <span class="k">exec</span> <span class="s">&quot;</span><span class="si">%s</span><span class="s">=1&quot;</span> <span class="o">%</span> <span class="n">name</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">func</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">):</span>
<span class="gp">&gt;&gt;&gt; </span>    <span class="k">for</span> <span class="n">var</span><span class="p">,</span> <span class="n">val</span> <span class="ow">in</span> <span class="n">kw</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
<span class="gp">&gt;&gt;&gt; </span>        <span class="k">exec</span> <span class="s">&quot;s.</span><span class="si">%s</span><span class="s">=val&quot;</span> <span class="o">%</span> <span class="n">var</span>  <span class="c"># invalid!</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">execfile</span><span class="p">(</span><span class="s">&quot;handler.py&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">handle</span><span class="p">()</span>
</pre></div>
</div>
<p>Good examples:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="p">{}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mf">1</span><span class="p">:]:</span>
<span class="gp">&gt;&gt;&gt; </span>    <span class="n">d</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="mf">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">func</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">):</span>
<span class="gp">&gt;&gt;&gt; </span>    <span class="k">for</span> <span class="n">var</span><span class="p">,</span> <span class="n">val</span> <span class="ow">in</span> <span class="n">kw</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
<span class="gp">&gt;&gt;&gt; </span>        <span class="nb">setattr</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">var</span><span class="p">,</span> <span class="n">val</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">=</span><span class="p">{}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">execfile</span><span class="p">(</span><span class="s">&quot;handle.py&quot;</span><span class="p">,</span> <span class="n">d</span><span class="p">,</span> <span class="n">d</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">handle</span> <span class="o">=</span> <span class="n">d</span><span class="p">[</span><span class="s">&#39;handle&#39;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">handle</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="section" id="from-module-import-name1-name2">
<h3>from module import name1, name2<a class="headerlink" href="#from-module-import-name1-name2" title="Permalink to this headline">¶</a></h3>
<p>This is a &#8220;don&#8217;t&#8221; which is much weaker then the previous &#8220;don&#8217;t&#8221;s but is still
something you should not do if you don&#8217;t have good reasons to do that. The
reason it is usually bad idea is because you suddenly have an object which lives
in two separate namespaces. When the binding in one namespace changes, the
binding in the other will not, so there will be a discrepancy between them. This
happens when, for example, one module is reloaded, or changes the definition of
a function at runtime.</p>
<p>Bad example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># foo.py</span>
<span class="n">a</span> <span class="o">=</span> <span class="mf">1</span>

<span class="c"># bar.py</span>
<span class="kn">from</span> <span class="nn">foo</span> <span class="kn">import</span> <span class="n">a</span>
<span class="k">if</span> <span class="n">something</span><span class="p">():</span>
    <span class="n">a</span> <span class="o">=</span> <span class="mf">2</span> <span class="c"># danger: foo.a != a</span>
</pre></div>
</div>
<p>Good example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># foo.py</span>
<span class="n">a</span> <span class="o">=</span> <span class="mf">1</span>

<span class="c"># bar.py</span>
<span class="kn">import</span> <span class="nn">foo</span>
<span class="k">if</span> <span class="n">something</span><span class="p">():</span>
    <span class="n">foo</span><span class="o">.</span><span class="n">a</span> <span class="o">=</span> <span class="mf">2</span>
</pre></div>
</div>
</div>
<div class="section" id="except">
<h3>except:<a class="headerlink" href="#except" title="Permalink to this headline">¶</a></h3>
<p>Python has the <tt class="docutils literal"><span class="pre">except:</span></tt> clause, which catches all exceptions. Since <em>every</em>
error in Python raises an exception, this makes many programming errors look
like runtime problems, and hinders the debugging process.</p>
<p>The following code shows a great example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">try</span><span class="p">:</span>
    <span class="n">foo</span> <span class="o">=</span> <span class="n">opne</span><span class="p">(</span><span class="s">&quot;file&quot;</span><span class="p">)</span> <span class="c"># misspelled &quot;open&quot;</span>
<span class="k">except</span><span class="p">:</span>
    <span class="n">sys</span><span class="o">.</span><span class="n">exit</span><span class="p">(</span><span class="s">&quot;could not open file!&quot;</span><span class="p">)</span>
</pre></div>
</div>
<p>The second line triggers a <a title="exceptions.NameError" class="reference external" href="../library/exceptions.html#exceptions.NameError"><tt class="xref docutils literal"><span class="pre">NameError</span></tt></a> which is caught by the except
clause. The program will exit, and you will have no idea that this has nothing
to do with the readability of <tt class="docutils literal"><span class="pre">&quot;file&quot;</span></tt>.</p>
<p>The example above is better written</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">try</span><span class="p">:</span>
    <span class="n">foo</span> <span class="o">=</span> <span class="n">opne</span><span class="p">(</span><span class="s">&quot;file&quot;</span><span class="p">)</span> <span class="c"># will be changed to &quot;open&quot; as soon as we run it</span>
<span class="k">except</span> <span class="ne">IOError</span><span class="p">:</span>
    <span class="n">sys</span><span class="o">.</span><span class="n">exit</span><span class="p">(</span><span class="s">&quot;could not open file&quot;</span><span class="p">)</span>
</pre></div>
</div>
<p>There are some situations in which the <tt class="docutils literal"><span class="pre">except:</span></tt> clause is useful: for
example, in a framework when running callbacks, it is good not to let any
callback disturb the framework.</p>
</div>
</div>
<div class="section" id="exceptions">
<h2>Exceptions<a class="headerlink" href="#exceptions" title="Permalink to this headline">¶</a></h2>
<p>Exceptions are a useful feature of Python. You should learn to raise them
whenever something unexpected occurs, and catch them only where you can do
something about them.</p>
<p>The following is a very popular anti-idiom</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">get_status</span><span class="p">(</span><span class="nb">file</span><span class="p">):</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">exists</span><span class="p">(</span><span class="nb">file</span><span class="p">):</span>
        <span class="k">print</span> <span class="s">&quot;file not found&quot;</span>
        <span class="n">sys</span><span class="o">.</span><span class="n">exit</span><span class="p">(</span><span class="mf">1</span><span class="p">)</span>
    <span class="k">return</span> <span class="nb">open</span><span class="p">(</span><span class="nb">file</span><span class="p">)</span><span class="o">.</span><span class="n">readline</span><span class="p">()</span>
</pre></div>
</div>
<p>Consider the case the file gets deleted between the time the call to
<a title="os.path.exists" class="reference external" href="../library/os.path.html#os.path.exists"><tt class="xref docutils literal"><span class="pre">os.path.exists()</span></tt></a> is made and the time <a title="open" class="reference external" href="../library/functions.html#open"><tt class="xref docutils literal"><span class="pre">open()</span></tt></a> is called. That means
the last line will throw an <a title="exceptions.IOError" class="reference external" href="../library/exceptions.html#exceptions.IOError"><tt class="xref docutils literal"><span class="pre">IOError</span></tt></a>. The same would happen if <em>file</em>
exists but has no read permission. Since testing this on a normal machine on
existing and non-existing files make it seem bugless, that means in testing the
results will seem fine, and the code will get shipped. Then an unhandled
<a title="exceptions.IOError" class="reference external" href="../library/exceptions.html#exceptions.IOError"><tt class="xref docutils literal"><span class="pre">IOError</span></tt></a> escapes to the user, who has to watch the ugly traceback.</p>
<p>Here is a better way to do it.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">get_status</span><span class="p">(</span><span class="nb">file</span><span class="p">):</span>
    <span class="k">try</span><span class="p">:</span>
        <span class="k">return</span> <span class="nb">open</span><span class="p">(</span><span class="nb">file</span><span class="p">)</span><span class="o">.</span><span class="n">readline</span><span class="p">()</span>
    <span class="k">except</span> <span class="p">(</span><span class="ne">IOError</span><span class="p">,</span> <span class="ne">OSError</span><span class="p">):</span>
        <span class="k">print</span> <span class="s">&quot;file not found&quot;</span>
        <span class="n">sys</span><span class="o">.</span><span class="n">exit</span><span class="p">(</span><span class="mf">1</span><span class="p">)</span>
</pre></div>
</div>
<p>In this version, *either* the file gets opened and the line is read (so it
works even on flaky NFS or SMB connections), or the message is printed and the
application aborted.</p>
<p>Still, <tt class="xref docutils literal"><span class="pre">get_status()</span></tt> makes too many assumptions &#8212; that it will only be
used in a short running script, and not, say, in a long running server. Sure,
the caller could do something like</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">try</span><span class="p">:</span>
    <span class="n">status</span> <span class="o">=</span> <span class="n">get_status</span><span class="p">(</span><span class="n">log</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">SystemExit</span><span class="p">:</span>
    <span class="n">status</span> <span class="o">=</span> <span class="bp">None</span>
</pre></div>
</div>
<p>So, try to make as few <tt class="docutils literal"><span class="pre">except</span></tt> clauses in your code &#8212; those will usually be
a catch-all in the <tt class="xref docutils literal"><span class="pre">main()</span></tt>, or inside calls which should always succeed.</p>
<p>So, the best version is probably</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">get_status</span><span class="p">(</span><span class="nb">file</span><span class="p">):</span>
    <span class="k">return</span> <span class="nb">open</span><span class="p">(</span><span class="nb">file</span><span class="p">)</span><span class="o">.</span><span class="n">readline</span><span class="p">()</span>
</pre></div>
</div>
<p>The caller can deal with the exception if it wants (for example, if it  tries
several files in a loop), or just let the exception filter upwards to <em>its</em>
caller.</p>
<p>The last version is not very good either &#8212; due to implementation details, the
file would not be closed when an exception is raised until the handler finishes,
and perhaps not at all in non-C implementations (e.g., Jython).</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">get_status</span><span class="p">(</span><span class="nb">file</span><span class="p">):</span>
    <span class="n">fp</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="nb">file</span><span class="p">)</span>
    <span class="k">try</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">fp</span><span class="o">.</span><span class="n">readline</span><span class="p">()</span>
    <span class="k">finally</span><span class="p">:</span>
        <span class="n">fp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="section" id="using-the-batteries">
<h2>Using the Batteries<a class="headerlink" href="#using-the-batteries" title="Permalink to this headline">¶</a></h2>
<p>Every so often, people seem to be writing stuff in the Python library again,
usually poorly. While the occasional module has a poor interface, it is usually
much better to use the rich standard library and data types that come with
Python then inventing your own.</p>
<p>A useful module very few people know about is <a title="Operations on pathnames." class="reference external" href="../library/os.path.html#module-os.path"><tt class="xref docutils literal"><span class="pre">os.path</span></tt></a>. It  always has the
correct path arithmetic for your operating system, and will usually be much
better then whatever you come up with yourself.</p>
<p>Compare:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># ugh!</span>
<span class="k">return</span> <span class="nb">dir</span><span class="o">+</span><span class="s">&quot;/&quot;</span><span class="o">+</span><span class="nb">file</span>
<span class="c"># better</span>
<span class="k">return</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">dir</span><span class="p">,</span> <span class="nb">file</span><span class="p">)</span>
</pre></div>
</div>
<p>More useful functions in <a title="Operations on pathnames." class="reference external" href="../library/os.path.html#module-os.path"><tt class="xref docutils literal"><span class="pre">os.path</span></tt></a>: <tt class="xref docutils literal"><span class="pre">basename()</span></tt>,  <tt class="xref docutils literal"><span class="pre">dirname()</span></tt> and
<tt class="xref docutils literal"><span class="pre">splitext()</span></tt>.</p>
<p>There are also many useful builtin functions people seem not to be aware of for
some reason: <a title="min" class="reference external" href="../library/functions.html#min"><tt class="xref docutils literal"><span class="pre">min()</span></tt></a> and <a title="max" class="reference external" href="../library/functions.html#max"><tt class="xref docutils literal"><span class="pre">max()</span></tt></a> can find the minimum/maximum of any
sequence with comparable semantics, for example, yet many people write their own
<a title="max" class="reference external" href="../library/functions.html#max"><tt class="xref docutils literal"><span class="pre">max()</span></tt></a>/<a title="min" class="reference external" href="../library/functions.html#min"><tt class="xref docutils literal"><span class="pre">min()</span></tt></a>. Another highly useful function is <a title="reduce" class="reference external" href="../library/functions.html#reduce"><tt class="xref docutils literal"><span class="pre">reduce()</span></tt></a>. A
classical use of <a title="reduce" class="reference external" href="../library/functions.html#reduce"><tt class="xref docutils literal"><span class="pre">reduce()</span></tt></a> is something like</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">sys</span><span class="o">,</span> <span class="nn">operator</span>
<span class="n">nums</span> <span class="o">=</span> <span class="nb">map</span><span class="p">(</span><span class="nb">float</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mf">1</span><span class="p">:])</span>
<span class="k">print</span> <span class="nb">reduce</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">add</span><span class="p">,</span> <span class="n">nums</span><span class="p">)</span><span class="o">/</span><span class="nb">len</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span>
</pre></div>
</div>
<p>This cute little script prints the average of all numbers given on the command
line. The <a title="reduce" class="reference external" href="../library/functions.html#reduce"><tt class="xref docutils literal"><span class="pre">reduce()</span></tt></a> adds up all the numbers, and the rest is just some
pre- and postprocessing.</p>
<p>On the same note, note that <a title="float" class="reference external" href="../library/functions.html#float"><tt class="xref docutils literal"><span class="pre">float()</span></tt></a>, <a title="int" class="reference external" href="../library/functions.html#int"><tt class="xref docutils literal"><span class="pre">int()</span></tt></a> and <a title="long" class="reference external" href="../library/functions.html#long"><tt class="xref docutils literal"><span class="pre">long()</span></tt></a> all
accept arguments of type string, and so are suited to parsing &#8212; assuming you
are ready to deal with the <a title="exceptions.ValueError" class="reference external" href="../library/exceptions.html#exceptions.ValueError"><tt class="xref docutils literal"><span class="pre">ValueError</span></tt></a> they raise.</p>
</div>
<div class="section" id="using-backslash-to-continue-statements">
<h2>Using Backslash to Continue Statements<a class="headerlink" href="#using-backslash-to-continue-statements" title="Permalink to this headline">¶</a></h2>
<p>Since Python treats a newline as a statement terminator, and since statements
are often more then is comfortable to put in one line, many people do:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">if</span> <span class="n">foo</span><span class="o">.</span><span class="n">bar</span><span class="p">()[</span><span class="s">&#39;first&#39;</span><span class="p">][</span><span class="mf">0</span><span class="p">]</span> <span class="o">==</span> <span class="n">baz</span><span class="o">.</span><span class="n">quux</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span> <span class="mf">2</span><span class="p">)[</span><span class="mf">5</span><span class="p">:</span><span class="mf">9</span><span class="p">]</span> <span class="ow">and</span> \
   <span class="n">calculate_number</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span> <span class="mf">20</span><span class="p">)</span> <span class="o">!=</span> <span class="n">forbulate</span><span class="p">(</span><span class="mf">500</span><span class="p">,</span> <span class="mf">360</span><span class="p">):</span>
      <span class="k">pass</span>
</pre></div>
</div>
<p>You should realize that this is dangerous: a stray space after the <tt class="docutils literal"><span class="pre">\</span></tt> would
make this line wrong, and stray spaces are notoriously hard to see in editors.
In this case, at least it would be a syntax error, but if the code was:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">value</span> <span class="o">=</span> <span class="n">foo</span><span class="o">.</span><span class="n">bar</span><span class="p">()[</span><span class="s">&#39;first&#39;</span><span class="p">][</span><span class="mf">0</span><span class="p">]</span><span class="o">*</span><span class="n">baz</span><span class="o">.</span><span class="n">quux</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span> <span class="mf">2</span><span class="p">)[</span><span class="mf">5</span><span class="p">:</span><span class="mf">9</span><span class="p">]</span> \
        <span class="o">+</span> <span class="n">calculate_number</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span> <span class="mf">20</span><span class="p">)</span><span class="o">*</span><span class="n">forbulate</span><span class="p">(</span><span class="mf">500</span><span class="p">,</span> <span class="mf">360</span><span class="p">)</span>
</pre></div>
</div>
<p>then it would just be subtly wrong.</p>
<p>It is usually much better to use the implicit continuation inside parenthesis:</p>
<p>This version is bulletproof:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">value</span> <span class="o">=</span> <span class="p">(</span><span class="n">foo</span><span class="o">.</span><span class="n">bar</span><span class="p">()[</span><span class="s">&#39;first&#39;</span><span class="p">][</span><span class="mf">0</span><span class="p">]</span><span class="o">*</span><span class="n">baz</span><span class="o">.</span><span class="n">quux</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span> <span class="mf">2</span><span class="p">)[</span><span class="mf">5</span><span class="p">:</span><span class="mf">9</span><span class="p">]</span>
        <span class="o">+</span> <span class="n">calculate_number</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span> <span class="mf">20</span><span class="p">)</span><span class="o">*</span><span class="n">forbulate</span><span class="p">(</span><span class="mf">500</span><span class="p">,</span> <span class="mf">360</span><span class="p">))</span>
</pre></div>
</div>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
            <h3><a href="../contents.html">Table Of Contents</a></h3>
            <ul>
<li><a class="reference external" href="">Idioms and Anti-Idioms in Python</a><ul>
<li><a class="reference external" href="#language-constructs-you-should-not-use">Language Constructs You Should Not Use</a><ul>
<li><a class="reference external" href="#from-module-import">from module import *</a><ul>
<li><a class="reference external" href="#inside-function-definitions">Inside Function Definitions</a></li>
<li><a class="reference external" href="#at-module-level">At Module Level</a></li>
<li><a class="reference external" href="#when-it-is-just-fine">When It Is Just Fine</a></li>
</ul>
</li>
<li><a class="reference external" href="#unadorned-exec-execfile-and-friends">Unadorned <tt class="docutils literal"><span class="pre">exec</span></tt>, <tt class="docutils literal"><span class="pre">execfile()</span></tt> and friends</a></li>
<li><a class="reference external" href="#from-module-import-name1-name2">from module import name1, name2</a></li>
<li><a class="reference external" href="#except">except:</a></li>
</ul>
</li>
<li><a class="reference external" href="#exceptions">Exceptions</a></li>
<li><a class="reference external" href="#using-the-batteries">Using the Batteries</a></li>
<li><a class="reference external" href="#using-backslash-to-continue-statements">Using Backslash to Continue Statements</a></li>
</ul>
</li>
</ul>

            <h4>Previous topic</h4>
            <p class="topless"><a href="curses.html"
                                  title="previous chapter">Curses Programming with Python</a></p>
            <h4>Next topic</h4>
            <p class="topless"><a href="functional.html"
                                  title="next chapter">Functional Programming HOWTO</a></p>
            <h3>This Page</h3>
            <ul class="this-page-menu">
              <li><a href="../_sources/howto/doanddont.txt"
                     rel="nofollow">Show Source</a></li>
            </ul>
          <div id="searchbox" style="display: none">
            <h3>Quick search</h3>
              <form class="search" action="../search.html" method="get">
                <input type="text" name="q" size="18" />
                <input type="submit" value="Go" />
                <input type="hidden" name="check_keywords" value="yes" />
                <input type="hidden" name="area" value="default" />
              </form>
              <p class="searchtip" style="font-size: 90%">
              Enter search terms or a module, class or function name.
              </p>
          </div>
          <script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="../modindex.html" title="Global Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="functional.html" title="Functional Programming HOWTO"
             >next</a> |</li>
        <li class="right" >
          <a href="curses.html" title="Curses Programming with Python"
             >previous</a> |</li>
        <li><img src="../_static/py.png" alt=""
                 style="vertical-align: middle; margin-top: -1px"/></li>
        <li><a href="../index.html">Python v2.6.2 documentation</a> &raquo;</li>

          <li><a href="index.html" >Python HOWTOs</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
      &copy; <a href="../copyright.html">Copyright</a> 1990-2009, Python Software Foundation.
      Last updated on Apr 15, 2009.
      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.1.
    </div>
  </body>
</html>